package tech.aistar.day13;

import java.io.*;

/**
 * 本类用来演示: IO流
 *
 * @author: success
 * @date: 2021/3/24 10:20 上午
 */
public class IODemo {
    public static void main(String[] args) {
        version03("src/tech/aistar/day13/FileDemo.java","src/tech/aistar/day13/FileDemo_副本.txt");
        //versino02("src/tech/aistar/day13/v.jpg","src/tech/aistar/day13/v_copy.jpg");
    }

    /**
     * 性能极其低下的 - 单个字节读写
     * @param src 源头
     * @param target 目标
     */
    public static void versino01(String src,String target){
        //1. 选择何种流 - FileInputStream/FileOutputStream
        //2. 确定源头和目标
        //面向父类编程
        InputStream in = null;//输入流
        OutputStream out = null;//输出流
        try {
             in = new FileInputStream(src);
             out = new FileOutputStream(target);

             //性能比较低的读取 - 单个字节单个字节进行读取.
            while(true){
                //从输入流中读取下一个字节
                int content = in.read();//如果已经到达流的末尾了,则返回-1

                if(content == -1)
                    break;

                out.write(content);//单个字节写出去,将指定的字节写入此输出流
            }

            System.out.println("文件拷贝...");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //流是一个比较昂贵的资源 - 使用完毕之后,一定要关闭...
            try{
                if(null!=in){
                    in.close();
                }
                if(null!=out){
                    out.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

    /**
     * 改进 - 提高读写性能 - 自定义的byte[] - 自定义的缓存区
     * @param src
     * @param target
     */
    public static void versino02(String src,String target){
        //1. 选择何种流 - FileInputStream/FileOutputStream
        //2. 确定源头和目标
        //面向父类编程
        InputStream in = null;//输入流
        OutputStream out = null;//输出流
        try {
            in = new FileInputStream(src);
            out = new FileOutputStream(target);

            //自定义一个缓冲区
            byte[] buf = new byte[8*1024];//8KB


            //性能比较低的读取 - 单个字节单个字节进行读取.
            while(true){
                //从输入流读取一些字节数，并将它们存储到缓冲区 `buf`
                int len = in.read(buf);

                if(len == -1)
                    break;

                //从指定的字节数组写入 `len`个字节，从偏移 `off`开始输出到此输出流。
                out.write(buf,0,len);
            }

            System.out.println("文件拷贝...");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //流是一个比较昂贵的资源 - 使用完毕之后,一定要关闭...
            try{
                if(null!=in){
                    in.close();
                }
                if(null!=out){
                    out.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

    /**
     * jdk7.x用到的一个语法糖的写法 - 把资源的关闭交给了JVM
     *
     * try(资源的声明;资源的声明){
     *
     * }catch(异常 e){
     *     //...
     * }
     *
     * @param src
     * @param target
     */
    public static void version03(String src,String target){
        try(InputStream in = new FileInputStream(src);
        OutputStream out = new FileOutputStream(target)){

            byte[] buf = new byte[8*1024];

            while(true){
                int len = in.read(buf);

                if(len == -1)
                    break;
                out.write(buf,0,len);
            }
            System.out.println("ok...");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
